import pylab as p
import math
from bpsk_modular_bits import modular_bits_en_bpsk
from funciones import generar_bits, sumar_ruido_gaussiano_blanco, detectar_bayesianamente, obtener_muestras_de_entrenamiento, estimar_fase_de_senial_bpsk, encontrar_alphas


# Argumentos

mostrar_intermedios = True
mostrar_resultado = True

lambda_01 = 0.5
lambda_11 = 0.5
N = 1000
alpha_0 = 0
alpha_1 = math.pi
A = 1
L = 8 
sigma2_W = 1
P_0 = lambda_01
P_1 = lambda_11

C_W = sigma2_W * p.identity(L)

def mostrar_intermedio(titulo, elemento):
    if(mostrar_intermedios):
        print "\t"+str(titulo)
        print "\t"+str(elemento)
      
def estimar_alpha(N_ent):  
    entrenamiento = obtener_muestras_de_entrenamiento(N_ent)    
    entrenamiento_modulado = modular_bits_en_bpsk(entrenamiento, alpha_0, alpha_1, A, L)    
    entrenamiento_modulado_mas_ruido = sumar_ruido_gaussiano_blanco(entrenamiento_modulado, sigma2_W)
    
    estimado = []
    for i in range(N_ent):
        estimado_i = estimar_fase_de_senial_bpsk(entrenamiento_modulado_mas_ruido[i * L:(i + 1) * L], A)
        estimado.append(estimado_i)

    return encontrar_alphas(entrenamiento, estimado)

print "Estimo fase con N=50"
alphas = estimar_alpha(100)
error = p.absolute(alphas[0]),p.absolute(math.pi-alphas[1])
mostrar_intermedio("Alphas:", alphas)
mostrar_intermedio("Error:", error)

print "Estimo fase con N=1000"
alphas = estimar_alpha(1000)
error = p.absolute(alphas[0]),p.absolute(math.pi-alphas[1])
mostrar_intermedio("Alphas:", alphas)
mostrar_intermedio("Error:", error)

print "Estimo fase con N=5000"
alphas = estimar_alpha(5000)
error = p.absolute(alphas[0]),p.absolute(math.pi-alphas[1])
mostrar_intermedio("Alphas:", alphas)
mostrar_intermedio("Error:", error)
